Credit Card Fraud Detection

Anonymized credit card transactions labeled as fraudulent or genuine

The dataset contains transactions made by credit cards in September 2013 by European cardholders. This dataset presents transactions that occurred in two days, where we have 492 frauds out of 284,807 transactions. The dataset is highly unbalanced, the positive class (frauds) account for 0.172% of all transactions.

It contains only numerical input variables which are the result of a PCA transformation. Unfortunately, due to confidentiality issues, we cannot provide the original features and more background information about the data. Features V1, V2, … V28 are the principal components obtained with PCA, the only features which have not been transformed with PCA are 'Time' and 'Amount'. Feature 'Time' contains the seconds elapsed between each transaction and the first transaction in the dataset. The feature 'Amount' is the transaction Amount, this feature can be used for example-dependant cost-sensitive learning. Feature 'Class' is the response variable and it takes value 1 in case of fraud and 0 otherwise.

Data acquired from https://www.kaggle.com/datasets/mlg-ulb/creditcardfraud

import pandas as pd
import seaborn as sns # Statistical data visualization
import matplotlib.pyplot as plt

df1 = pd.read_csv('data/creditcard.csv')   
df1.head(5)

	Time	V1	V2	V3	V4	V5	V6	V7	V8	V9	...	V21	V22	V23	V24	V25	V26	V27	V28	Amount	Class
0	0.0	-1.359807	-0.072781	2.536347	1.378155	-0.338321	0.462388	0.239599	0.098698	0.363787	...	-0.018307	0.277838	-0.110474	0.066928	0.128539	-0.189115	0.133558	-0.021053	149.62	0
1	0.0	1.191857	0.266151	0.166480	0.448154	0.060018	-0.082361	-0.078803	0.085102	-0.255425	...	-0.225775	-0.638672	0.101288	-0.339846	0.167170	0.125895	-0.008983	0.014724	2.69	0
2	1.0	-1.358354	-1.340163	1.773209	0.379780	-0.503198	1.800499	0.791461	0.247676	-1.514654	...	0.247998	0.771679	0.909412	-0.689281	-0.327642	-0.139097	-0.055353	-0.059752	378.66	0
3	1.0	-0.966272	-0.185226	1.792993	-0.863291	-0.010309	1.247203	0.237609	0.377436	-1.387024	...	-0.108300	0.005274	-0.190321	-1.175575	0.647376	-0.221929	0.062723	0.061458	123.50	0
4	2.0	-1.158233	0.877737	1.548718	0.403034	-0.407193	0.095921	0.592941	-0.270533	0.817739	...	-0.009431	0.798278	-0.137458	0.141267	-0.206010	0.502292	0.219422	0.215153	69.99	0

5 rows × 31 columns

Exploratory Data Analysis

First, some exploratory data analysis to see the more obvious correlations between data and fraud identification variable 'Class'.

plt.figure(figsize = (30, 30)) 
sns.heatmap(df1.corr(), annot = True);

The best candidates for correlation to the fraud id variable 'class' are columns V2, V4, V8, V11.

sns.pairplot(df1, hue = 'Class', vars = ['V2', 'V4', 'V8', 'V11']);

There does appear to be some prominent clustering of data points relating to fraud (in orange) away from the valid transactions. The variables V2, V8, and V11 could be candidates for further exploration.

Interactive 3d plot

class0_df = df1[ df1['Class'] == 0] # Valid transactionns
class1_df = df1[ df1['Class'] == 1] # Fraudulent transactions

import plotly.express as px
df1['dClass'] = df1['Class'].astype(str)
fig = px.scatter_3d(df1, x='V11', y='V2', z='V8', 
                    title='3D Scatter Plot - All data V11 V2 V8', color='dClass', opacity=0.7)

fig.update_layout(scene = dict(
                    xaxis = dict(
                         backgroundcolor="rgb(200, 200, 230)",
                         gridcolor="white",
                         showbackground=True,
                         zerolinecolor="white",),
                    yaxis = dict(
                        backgroundcolor="rgb(230, 200,230)",
                        gridcolor="white",
                        showbackground=True,
                        zerolinecolor="white"),
                    zaxis = dict(
                        backgroundcolor="rgb(230, 230,200)",
                        gridcolor="white",
                        showbackground=True,
                        zerolinecolor="white",),),
                    width=700,
                    margin=dict(
                    r=10, l=10,
                    b=10, t=30)
                  )
fig.update_traces(marker_size = 3)

fig = px.scatter_3d(class1_df, x='V11', y='V2', z='V8', 
                    title='3D Scatter Plot - Fraud data V11 V2 V8', opacity=0.7)

fig.update_layout(scene = dict(
                    xaxis = dict(
                         backgroundcolor="rgb(200, 200, 230)",
                         gridcolor="white",
                         showbackground=True,
                         zerolinecolor="white",),
                    yaxis = dict(
                        backgroundcolor="rgb(230, 200,230)",
                        gridcolor="white",
                        showbackground=True,
                        zerolinecolor="white"),
                    zaxis = dict(
                        backgroundcolor="rgb(230, 230,200)",
                        gridcolor="white",
                        showbackground=True,
                        zerolinecolor="white",),),
                    width=700,
                    margin=dict(
                    r=10, l=10,
                    b=10, t=30)
                  )
fig.update_traces(marker_size = 3)

Worth looking at just the fraudulent transactions as much of this data is buried within the cloud of legitimate transactions.

2d scatter plot

It looks like V11 and V2 contain most of the useful information, and a simple scatterplot can show this.

plt.figure(figsize = (15,15))

sns.scatterplot(x = 'V11', y = 'V2', hue = 'Class', data =  df1);

Improving the detection of fraud.

One solution to the problem of fraud identification might be to use a least error line fit between V11 and V2 and use a cutoff within a band above and below the line. This is not a perfect solution. It is a tradeoff between fraudulent transactions stopped and genuine transactions stopped. The metrics can be tested later.

y1 = class1_df['V2'].values.reshape(-1, 1)
X1 = class1_df['V11'].values.reshape(-1, 1)

from sklearn.model_selection import train_test_split
SEED = 42 # this just ensures the random selection of test point are reproducible
X_train, X_test, y_train, y_test = train_test_split(X1, y1, test_size = 0.95, random_state = SEED)

from sklearn.linear_model import LinearRegression
regressor = LinearRegression()

regressor.fit(X_train, y_train)
a = regressor.coef_[0,0]
b = regressor.intercept_[0]
print(regressor.intercept_[0])
print(regressor.coef_[0,0])

0.10270877141271217
0.9457284473912695

class1_df['yval'] = class1_df['V11'] * a + b  # y = ax+b

plt.figure(figsize = (15,15))

sns.scatterplot(x = 'V11', y = 'V2', data = class1_df)
sns.scatterplot(x = 'V11', y = 'yval', data = class1_df);

plt.figure(figsize = (15,15))

sns.scatterplot(x = 'V11', y = 'V2', hue = 'Class', data = df1)
sns.scatterplot(x = 'V11', y = 'yval', color = 'pink', data = class1_df);

Reviewing the analysis so far, I will go with the ridiculously simple solution of blocking transactions where V11 is above 4.

Checking the solution

# No of all blocked transactions 272
df1[df1['V11'] > 4].shape

(272, 32)

# No of good transactions that would be blocked
df1[(df1['V11'] > 4) & (df1['Class']==0)].shape

(60, 32)

# No of fraudulent transactions that would be stopped
df1[(df1['V11'] > 4) & (df1['Class']==1)].shape

(212, 32)

# Calulate the percentage of fraudulent transactions blocked if V11 is > 4
(212*100)/492

43.08943089430894

So a 43% decrease in credit card fraud (212 frauds stopped) but unfortunately this would mean that 60 valid transactions would also be stopped.

Conclusion

Although there is much more that can be done to improve the fraud detection rate and decrease false positive detections, this is an interesting problem that shows how a very simple solution can be found for a complex issue by using some data visualisation techniques. It would be interesting to compare the average values of the proposed blocked transactions with the overall average.

I confess I doubt the solution would stand the test of time. Fraud evolves and so must the solutions. Perhaps an adaptive machine learning algorithm would be better.